package artaza.controlador;

/**
 *
 * @author AGM
 */
import artaza.persistencia.Evento;
import artaza.persistencia.Trabaja;
import artaza.persistencia.Camarero;
import artaza.persistencia.Finca;
import artaza.service.CamareroService;
import artaza.service.EventoService;
import artaza.service.FincaService;
import artaza.service.TrabajaService;
import com.google.appengine.api.datastore.Key;
import com.google.appengine.api.datastore.KeyFactory;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
//import java.util.Iterator;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Required;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class EventoController {

    private EventoService eventoService;
    private TrabajaService trabajaService;
    private CamareroService camareroService;
    private FincaService fincaService;

    @Autowired
    @Required
    public void setEventoService(EventoService eventoService) {
        this.eventoService = eventoService;
    }

    @Autowired
    @Required
    public void setTrabajaService(TrabajaService trabajaService) {
        this.trabajaService = trabajaService;
    }

    @Autowired
    @Required
    public void setCamareroService(CamareroService camareroService) {
        this.camareroService = camareroService;
    }

    @Autowired
    @Required
    public void setFincaService(FincaService fincaService) {
        this.fincaService = fincaService;
    }

    @RequestMapping(value = "/listadoeventos", method = RequestMethod.GET)
    public String doShowEvento(Model model) {
        final Collection<Evento> eventos = eventoService.getAlleventos();
        model.addAttribute("eventos", eventos);
        final Collection<Trabaja> trabajos = trabajaService.getAlltrabajos();
        model.addAttribute("trabajos", trabajos);
        final Collection<Camarero> plantilla = camareroService.getAllcamareros();
        model.addAttribute("plantilla", plantilla);
        final Collection<Finca> espacios = fincaService.getAllFincas();
        model.addAttribute("espacios", espacios);
        return "/listadoeventos";
    }

    @RequestMapping(value = "/crear_evento", method = RequestMethod.POST)
    public String doCrearEvento(
            @RequestParam("nombre") String nombre,
            @RequestParam("invitados") int invitados,
            @RequestParam("fecha_evento") String fecha_evento,
            @RequestParam("telefono") String telefono,
            @RequestParam("correo") String correo,
            Model model) {
        if (nombre.length() == 0 || fecha_evento.length() == 0) {
            return "redirect:listadoeventos";
        }
        final Evento e = new Evento();
        e.setNombre(nombre);
        e.setInvitados(invitados);
        e.setFecha_evento(fecha_evento);
        e.setTelefono(telefono);
        e.setCorreo(correo);
        eventoService.create(e);
        return "redirect:listadoeventos";
    }

    @RequestMapping(value = "/borrar_evento", method = RequestMethod.POST)
    public /*@ResponseBody*/ String doBorrarEvento(@RequestParam("id_evento") String id_evento,
            Model model) {

        Evento e = eventoService.findByPK(KeyFactory.stringToKey(id_evento));
        System.out.println("ptt");
        /* Debo borrar el evento,pero antes debo eliminar la fecha
         * del evento a la finca que tenga asignada ese evento y liberar tb a los camareros. */
        if (e.getTrabajas().isEmpty()) {


            eventoService.remove(e.getId_evento());
            return "redirect:listadoeventos";

        } else {

            if (e.getTrabajas().get(0).getFinca() != null) {

                Finca f = fincaService.findByPK(e.getTrabajas().get(0).getFinca());
                f.getOcupado().remove(e.getFecha_evento());

            }

            if (e.getTrabajas().get(0).getCamtrabaja() != null) {

                for (Trabaja t : e.getTrabajas()) {
                    Camarero c = camareroService.findByPK(t.getCamtrabaja());
                    c.getTrabajoscamarero().remove(e.getFecha_evento());
                }
            }

        }
        //String mistring="hola";
        eventoService.remove(e.getId_evento());
        return "redirect:listadoeventos";
    }

    @RequestMapping(value = "/ir_crear_evento", method = RequestMethod.GET)
    public String doIrEventos() {
        return "/eventos";
    }

    @RequestMapping(value = "/anadirfincaalevento", method = RequestMethod.POST)
    public String doAnadirFincaAlEvento(@RequestParam("id_evento") String id_evento,
            @RequestParam("id_finca") String id_finca,
            Model model) {
        Evento e = eventoService.findByPK(KeyFactory.stringToKey(id_evento));
        Finca f = fincaService.findByPK(KeyFactory.stringToKey(id_finca));

        if (f.getOcupado().contains(e.getFecha_evento())) {
            /*Avisar al admin de que no se puede reservar esa finca...
            porque ya esta reservada u ocupada ese dia!!! */
            return "redirect:confirmarfincadisponible?estaocupada=si";
        }

        Trabaja t = e.crearTrabaja();          //Creo un Trabaja y le asigno el evento al ke pertence(y su fecha)
        t.setFinca(f.getId_finca());        //A ese Trabaja le meto una Key de Finca (Le asigno una finca)
        f.getOcupado().add(e.getFecha_evento());//Añado la fecha del evento a la lista de fechas ocupadas de la Finca.
        fincaService.update(f); //actualizo la finca
        t = trabajaService.update(t); //persisitir el trabaja
        return "redirect:confirmarfincadisponiblesi?estaocupada=no";
    }

    @RequestMapping(value = "/ir_asignar_finca", method = RequestMethod.GET)
    public String doIrAsignarFinca(@RequestParam("id_evento") String id_evento,
            Model model) {
        Evento e = eventoService.findByPK(KeyFactory.stringToKey(id_evento));
        model.addAttribute("evento", e);
        final Collection<Finca> espacios = fincaService.getAllFincas();
        model.addAttribute("espacios", espacios);
        return "/asignafincas";
    }

    @RequestMapping(value = "/irmodificarfincaasignadaevento", method = RequestMethod.GET)
    public String doIrModificarFincaAsignadaEvento(@RequestParam("id_evento") String id_evento,
            Model model) {
        Evento e = eventoService.findByPK(KeyFactory.stringToKey(id_evento));
        model.addAttribute("evento", e);
        final Collection<Finca> espacios = fincaService.getAllFincas();
        model.addAttribute("espacios", espacios);
        String modificar = "modificar";
        model.addAttribute("modificar", modificar);
        return "/asignafincas";
    }

    @RequestMapping(value = "/modificarfincaasignadaevento", method = RequestMethod.POST)
    public String doModificarFincaAsignadaEvento(@RequestParam("id_evento") String id_evento,
            @RequestParam("id_finca") String id_finca,
            Model model) {
        Evento e = eventoService.findByPK(KeyFactory.stringToKey(id_evento));
        Finca f = fincaService.findByPK(KeyFactory.stringToKey(id_finca));
        Finca antigua = dameFinca(e);//recupero la finca antigua para borrarle la fecha del evento.

        if (antigua.getIdString().equals(f.getIdString())) {
            //Por si intenta asignar la finca que ya esta asignada,avisamos de esto al admin
            return "redirect:confirmarfincadisponiblemod?estaocupadamodificarfinca=misma";
        }

        if (f.getOcupado().contains(e.getFecha_evento())) {
            //Si la finca no esta disponible se avisa al admin de que no es posible
            return "redirect:confirmarfincadisponiblemod?estaocupadamodificarfinca=si";
        }
        //Si la finca esta disponible se configura el evento con esa finca
        f.getOcupado().add(e.getFecha_evento());//a la finca le añado la fecha del evento a su lista de fechas ocupadas.
        antigua.getOcupado().remove(e.getFecha_evento());// a la finca antigua le quito la fecha del evento para q esa fecha quede libre
        //A continuacion se configura el evento con esa finca
        for (Trabaja trabaja : e.getTrabajas()) {
            trabaja.setFinca(f.getId_finca());
            trabajaService.update(trabaja);
        }
        return "redirect:confirmarfincadisponiblemod?estaocupadamodificarfinca=no";
    }

    @RequestMapping(value = "/ir_asignar_camarero", method = RequestMethod.GET)
    public String doirAsignarPersonal(@RequestParam("id_evento") String id_evento,
            Model model) {
        Evento e = eventoService.findByPK(KeyFactory.stringToKey(id_evento));
        model.addAttribute("evento", e);
        final Collection<Camarero> plantilla = camareroService.getAllcamareros();
        model.addAttribute("plantilla", plantilla);
        return "/asignapersonal";
    }

    @RequestMapping(value = "/anadirpersonalalevento", method = RequestMethod.GET)
    public String doAnadirPersonalAlEvento(@RequestParam("id_evento") String id_evento,
            @RequestParam("variable1") String personal,
            Model model) {

        String[] personalasignado = personal.split(",");


        if (personalasignado.length == 0 || personal.isEmpty()) {

            return "redirect:noasignastepersonal?asignar=no";
        }


        Evento e = eventoService.findByPK(KeyFactory.stringToKey(id_evento));

        if (e.getTrabajas().size() >= 1 && e.getTrabajas().get(0).getFinca() != null && e.getTrabajas().get(0).getCamtrabaja() != null) {

            //List<String> lista = Arrays.asList(personalasignado);
            List<String> lista = new ArrayList<String>();
            for (int j = 0; j <= (personalasignado.length - 1); j++) {

                lista.add(personalasignado[j]);
            }

            List<String> keys = new ArrayList<String>();

            for (Trabaja trabaja : e.getTrabajas()) {

                keys.add(KeyFactory.keyToString(trabaja.getCamtrabaja()));
            }

            System.out.println("Primer for: los que vienen");
            for (int i = 0; i <= (lista.size() - 1); i++) {
                System.out.println(lista.get(i));
                System.out.println("tamaño de la lista  : " + lista.size());
                System.out.println("limite de este for  : " + (lista.size() - 1));
            }
            System.out.println("Fin Primer for");
            System.out.println("Segundo for:");


            int p = 0;
            for (String s : keys) {
                if (lista.contains(s)) {
                    lista.remove(s);
                    p = 1;

                }

            }


            if (lista.isEmpty()) {
                return "redirect:todopersonalrepetido?repetidos=si";

            } else {
                for (int i = 0; i <= (lista.size() - 1); i++) {
                    System.out.println("ha añadido el ke falta    " + lista.get(i));
                    Trabaja t = e.crearTrabaja();
                    t.setCamtrabaja(KeyFactory.stringToKey(lista.get(i)));
                    t.setFinca(e.getTrabajas().get(0).getFinca());
                    t.setNombre(e.getNombre());
                    t.setFecha(e.getFecha_evento());
                }

                if (p == 1) {
                    return "redirect:habiarepetidos?habia=si";
                }
            }
        }


        if (e.getTrabajas().size() == 1 && e.getTrabajas().get(0).getFinca() != null && e.getTrabajas().get(0).getCamtrabaja() == null) {
            System.out.println("AÑADO POR PRIMERA VEZ AL EVENTO");
            e.getTrabajas().get(0).setCamtrabaja(KeyFactory.stringToKey(personalasignado[0]));
            for (int i = 1; i <= (personalasignado.length - 1); i++) {
                Trabaja t = e.crearTrabaja();
                t.setCamtrabaja(KeyFactory.stringToKey(personalasignado[i]));
                t.setFinca(e.getTrabajas().get(0).getFinca());
                t.setNombre(e.getNombre());
                t.setFecha(e.getFecha_evento());
            }

        }

        for (Trabaja trab : e.getTrabajas()) {
            Camarero camarero = camareroService.findByPK(trab.getCamtrabaja());
            if (!camarero.getTrabajoscamarero().contains(e.getFecha_evento())) {
                camarero.getTrabajoscamarero().add(e.getFecha_evento());
            }
        }


        return "redirect:todosasignados?asignados=si";
    }

    @RequestMapping(value = "/irverpersonal", method = RequestMethod.GET)
    public String doirVerPersonal(@RequestParam("id_evento") String id_evento,
            Model model) {
        Evento e = eventoService.findByPK(KeyFactory.stringToKey(id_evento));
        List<String> lista = new ArrayList<String>();

        for (Trabaja trabaja : e.getTrabajas()) {

            if (trabaja.getCamtrabaja() != null) {
                lista.add(trabaja.getIdStringCamarero());
            }
        }

        String info = e.getNombre() + "  Fecha: " + e.getFecha_evento();
        model.addAttribute("lista", lista);
        model.addAttribute("evento", e);
        model.addAttribute("info", info);
        final Collection<Camarero> plantilla = camareroService.getAllcamareros();
        model.addAttribute("plantilla", plantilla);
        return "/verpersonal";
    }

    public Finca dameFinca(Evento e) {
        /*Uso este metodo para cuando modifico la finca asignada a un evento.
        En ese metodo necesito saber la finca antigua para poder quitarle la fecha de ocupado
        y añadirle esa fecha a la finca nueva que se desea asignar,
        si esta última está disponible para ello */
        Key delafincaantigua = e.getTrabajas().get(0).getFinca();
        Finca f = fincaService.findByPK(delafincaantigua);
        return f;
    }

    @RequestMapping(value = "/confirmarfincadisponible", method = RequestMethod.GET)
    public String confirmarFinca(@RequestParam(value = "estaocupada", required = true) String estaocupada, Model model) {
        model.addAttribute("estaocupada", estaocupada);
        final Collection<Evento> eventos = eventoService.getAlleventos();
        model.addAttribute("eventos", eventos);
        final Collection<Trabaja> trabajos = trabajaService.getAlltrabajos();
        model.addAttribute("trabajos", trabajos);
        final Collection<Camarero> plantilla = camareroService.getAllcamareros();
        model.addAttribute("plantilla", plantilla);
        final Collection<Finca> espacios = fincaService.getAllFincas();
        model.addAttribute("espacios", espacios);
        System.out.println(estaocupada);
        return "/listadoeventos";
    }

    @RequestMapping(value = "/confirmarfincadisponiblemod", method = RequestMethod.GET)
    public String confirmarFincaMod(@RequestParam(value = "estaocupadamodificarfinca", required = true) String estaocupadamodificarfinca, Model model) {
        model.addAttribute("estaocupadamodificarfinca", estaocupadamodificarfinca);
        final Collection<Evento> eventos = eventoService.getAlleventos();
        model.addAttribute("eventos", eventos);
        final Collection<Trabaja> trabajos = trabajaService.getAlltrabajos();
        model.addAttribute("trabajos", trabajos);
        final Collection<Camarero> plantilla = camareroService.getAllcamareros();
        model.addAttribute("plantilla", plantilla);
        final Collection<Finca> espacios = fincaService.getAllFincas();
        model.addAttribute("espacios", espacios);
        System.out.println(estaocupadamodificarfinca);
        return "/listadoeventos";
    }

    @RequestMapping(value = "/confirmarfincadisponiblesi", method = RequestMethod.GET)
    public String confirmarFincaSi(@RequestParam(value = "estaocupada", required = true) String estaocupada, Model model) {
        model.addAttribute("estaocupada", estaocupada);
        final Collection<Evento> eventos = eventoService.getAlleventos();
        model.addAttribute("eventos", eventos);
        final Collection<Trabaja> trabajos = trabajaService.getAlltrabajos();
        model.addAttribute("trabajos", trabajos);
        final Collection<Camarero> plantilla = camareroService.getAllcamareros();
        model.addAttribute("plantilla", plantilla);
        final Collection<Finca> espacios = fincaService.getAllFincas();
        model.addAttribute("espacios", espacios);
        System.out.println(estaocupada);
        return "/listadoeventos";
    }

    @RequestMapping(value = "/ir_eliminar_personal", method = RequestMethod.GET)
    public String irEliminarPersonalDelEvento(@RequestParam("id_evento") String id_evento,
            Model model) {
        Evento e = eventoService.findByPK(KeyFactory.stringToKey(id_evento));
        List<String> lista = new ArrayList<String>();

        for (Trabaja trabaja : e.getTrabajas()) {

            if (trabaja.getCamtrabaja() != null) {
                lista.add(trabaja.getIdStringCamarero());
            }
        }

        String info = e.getNombre() + "  Fecha: " + e.getFecha_evento();
        model.addAttribute("lista", lista);
        model.addAttribute("evento", e);
        model.addAttribute("info", info);
        final Collection<Camarero> plantilla = camareroService.getAllcamareros();
        model.addAttribute("plantilla", plantilla);
        return "/eliminarpersonalev";

    }

    @RequestMapping(value = "/eliminar_personal", method = RequestMethod.GET)
    public String eliminarPersonal(@RequestParam("id_evento") String id_evento,
            @RequestParam("variable1") String personal,
            Model model) {

        String[] personaleliminado = personal.split(",");
        Evento e = eventoService.findByPK(KeyFactory.stringToKey(id_evento));
        List<Trabaja> milista = new ArrayList<Trabaja>();
        for (Trabaja t : e.getTrabajas()) {
            milista.add(t);
        }

        String f = "hay finca asignada";
        if (e.getTrabajas().get(0).getFinca() == null) {
            f = "no hay finca asignada";
        }

        if (f.equals("hay finca asignada") == true && personaleliminado.length == e.getTrabajas().size()) {
            Trabaja mitrabaja = new Trabaja();
            mitrabaja.setFinca(milista.get(0).getFinca());
            mitrabaja.setNombre(e.getNombre());
            mitrabaja.setFecha(e.getFecha_evento());

            for (int i = 0; i <= (personaleliminado.length - 1); i++) {
                Camarero micam = camareroService.findByPK(KeyFactory.stringToKey(personaleliminado[i]));
                if (micam.getTrabajoscamarero().contains(e.getFecha_evento())) {
                    micam.getTrabajoscamarero().remove(e.getFecha_evento());
                }
            }

            milista.clear();
            milista.add(mitrabaja);
            e.getTrabajas().clear();
            Trabaja trab = e.crearTrabaja();
            trab.setFinca(milista.get(0).getFinca());
            trab.setNombre(e.getNombre());
            trab.setFecha(e.getFecha_evento());
            trabajaService.update(trab);
        }

        if (personaleliminado.length < e.getTrabajas().size()) {
            e.getTrabajas().clear();
            for (int i = 0; i <= (personaleliminado.length - 1); i++) {

                for (int j = 0; j <= (milista.size() - 1); j++) {
                    if (personaleliminado[i].compareTo(milista.get(j).getIdStringCamarero()) == 0) {


                        Camarero c = camareroService.findByPK(milista.get(j).getCamtrabaja());
                        c.getTrabajoscamarero().remove(e.getFecha_evento());
                        milista.remove(milista.get(j));
                    }
                }
            }
            for (Trabaja trabaja : milista) {
                //e.getTrabajas().add(trabaja);no ha funcionado,el evento se quedaba vacio
                Trabaja t = e.crearTrabaja();
                t.setNombre(e.getNombre());
                t.setFecha(e.getFecha_evento());
                t.setFinca(trabaja.getFinca());
                t.setCamtrabaja(trabaja.getCamtrabaja());
                t.setHoras(trabaja.getHoras());
                trabajaService.update(t);
            }
        }
        return "redirect:listadoeventos";
    }

    @RequestMapping(value = "/noasignastepersonal", method = RequestMethod.GET)
    public String noAsignastePersonal(@RequestParam(value = "asignar", required = true) String asignar, Model model) {
        model.addAttribute("asignar", asignar);
        final Collection<Evento> eventos = eventoService.getAlleventos();
        model.addAttribute("eventos", eventos);
        final Collection<Trabaja> trabajos = trabajaService.getAlltrabajos();
        model.addAttribute("trabajos", trabajos);
        final Collection<Camarero> plantilla = camareroService.getAllcamareros();
        model.addAttribute("plantilla", plantilla);
        final Collection<Finca> espacios = fincaService.getAllFincas();
        model.addAttribute("espacios", espacios);
        System.out.println(asignar);
        return "/listadoeventos";
    }

    @RequestMapping(value = "/todopersonalrepetido", method = RequestMethod.GET)
    public String todoPersonalRepetido(@RequestParam(value = "repetidos", required = true) String repetidos, Model model) {
        model.addAttribute("repetidos", repetidos);
        final Collection<Evento> eventos = eventoService.getAlleventos();
        model.addAttribute("eventos", eventos);
        final Collection<Trabaja> trabajos = trabajaService.getAlltrabajos();
        model.addAttribute("trabajos", trabajos);
        final Collection<Camarero> plantilla = camareroService.getAllcamareros();
        model.addAttribute("plantilla", plantilla);
        final Collection<Finca> espacios = fincaService.getAllFincas();
        model.addAttribute("espacios", espacios);

        return "/listadoeventos";
    }

    @RequestMapping(value = "/habiarepetidos", method = RequestMethod.GET)
    public String habiaPersonalRepetido(@RequestParam(value = "habia", required = true) String habia, Model model) {
        model.addAttribute("habia", habia);
        final Collection<Evento> eventos = eventoService.getAlleventos();
        model.addAttribute("eventos", eventos);
        final Collection<Trabaja> trabajos = trabajaService.getAlltrabajos();
        model.addAttribute("trabajos", trabajos);
        final Collection<Camarero> plantilla = camareroService.getAllcamareros();
        model.addAttribute("plantilla", plantilla);
        final Collection<Finca> espacios = fincaService.getAllFincas();
        model.addAttribute("espacios", espacios);

        return "/listadoeventos";
    }

    @RequestMapping(value = "/todosasignados", method = RequestMethod.GET)
    public String todosAsignados(@RequestParam(value = "asignados", required = true) String asignados, Model model) {
        model.addAttribute("asignados", asignados);
        final Collection<Evento> eventos = eventoService.getAlleventos();
        model.addAttribute("eventos", eventos);
        final Collection<Trabaja> trabajos = trabajaService.getAlltrabajos();
        model.addAttribute("trabajos", trabajos);
        final Collection<Camarero> plantilla = camareroService.getAllcamareros();
        model.addAttribute("plantilla", plantilla);
        final Collection<Finca> espacios = fincaService.getAllFincas();
        model.addAttribute("espacios", espacios);

        return "/listadoeventos";
    }

    @RequestMapping(value = "/adminSecured/ir_ver_trabajos", method = RequestMethod.GET)
    public String doIrVerTrabajos(@RequestParam("id") String id, Model model) {

        Collection<Evento> miseventos = eventoService.getAlleventos();
        List<Trabaja> milista = new ArrayList<Trabaja>();

        for (Evento ev : miseventos) {
            if (ev.getTrabajas().get(0).getCamtrabaja() != null) {

                for (Trabaja trabaja : ev.getTrabajas()) {
                    if (trabaja.getCamtrabaja().compareTo(KeyFactory.stringToKey(id)) == 0) {
                        milista.add(trabaja);
                    }
                }
            }
        }

        model.addAttribute("milista", milista);
        final Collection<Finca> espacios = fincaService.getAllFincas();
        model.addAttribute("espacios", espacios);

        return "/vertrabajos";
    }
}/*LLave de cierre de la clase EventoController*/
